< -package:ghc-lib-parser -package:base

(<) :: Ord a => a -> a -> Bool

ghc-prim GHC.Classes, hedgehog Hedgehog.Internal.Prelude, ghc GHC.Prelude.Basic, base-compat Prelude.Compat, protolude Protolude, relude Relude.Base, rio RIO.Prelude, base-prelude BasePrelude BasePrelude.Operators, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base, basic-prelude CorePrelude, universum Universum.Base, Cabal-syntax Distribution.Compat.Prelude, github GitHub.Internal.Prelude, numhask NumHask.Prelude, basement Basement.Compat.Base Basement.Imports, foundation Foundation, prelude-compat Prelude2010, dimensional Numeric.Units.Dimensional.Prelude, rebase Rebase.Prelude, quaalude Essentials, hledger Hledger.Cli.Script, xmonad-contrib XMonad.Config.Prime, stack Stack.Prelude, incipit-base Incipit.Base, LambdaHack Game.LambdaHack.Core.Prelude, cabal-install-solver Distribution.Solver.Compat.Prelude, loc Data.Loc.Internal.Prelude, universe-reverse-instances Data.Universe.Instances.Ord, yesod-paginator Yesod.Paginator.Prelude, distribution-opensuse OpenSuse.Prelude, faktory Faktory.Prelude, hledger-web Hledger.Web.Import, termonad Termonad.Prelude

data (<)

first-class-families Fcf Fcf.Data.Nat

data (<)

first-class-families Fcf.Class.Ord

"Smaller than". Type-level version of (<).

Example

>>> :kind! Eval ("a" < "b")
Eval ("a" < "b") :: Bool
= 'True

(<) :: OrdB a => a -> a -> BooleanOf a

Boolean Data.Boolean.Overload

type family (<) (arg_aKYz :: a_aKBH) (arg_aKYA :: a_aKBH) :: Bool

singletons-base Data.Ord.Singletons Data.Singletons.Base.TH Prelude.Singletons

type (<) a_aKZo a_aKZp = Apply (Apply TFHelper_6989586621679190424Sym0 a_aKZo) a_aKZp

singletons-base Data.Ord.Singletons Data.Singletons.Base.TH Prelude.Singletons

(<) :: JExpr -> JExpr -> JExpr

jmacro Language.Javascript.JMacro.Util

data (<)

natural-arithmetic Arithmetic.Types Arithmetic.Unsafe

Proof that the first argument is strictly less than the second argument.

(<) :: HasOrderAsymmetric a b => a -> b -> OrderCompareType a b

mixed-types-num Numeric.MixedTypes.Ord

(<) :: HasOrderAsymmetric t t => t -> t -> OrderCompareType t t

mixed-types-num Numeric.OrdGenericBool

(<) :: Order a => a -> a -> Bool

algebra Numeric.Algebra Numeric.Order.Class

type n < m = (n <? m) ~ 'True

type-natural Data.Type.Natural Data.Type.Natural.Lemma.Order

(<) :: Ord a => a % 1 -> a % 1 -> Bool

linear-base Data.Ord.Linear

(<) :: PartialOrd a => a -> a -> Bool

partial-order Data.PartialOrd

Less-than relation relation. Defined in terms of <= and /=.

type (a :: k1) < (b :: k2) = (b <=? a) ~ 'False

typenums Data.TypeLits Data.TypeNums

(<>) :: Builder -> Builder -> Builder

text Data.Text.Internal.Builder.Functions

The normal mappend function with right associativity instead of left.

(<|) :: a -> Seq a -> Seq a

containers Data.Sequence Data.Sequence.Internal

Add an element to the left end of a sequence. Mnemonic: a triangle with the single element at the pointy end.

(<.>) :: FilePath -> String -> FilePath

filepath System.FilePath System.FilePath.Posix System.FilePath.Windows

Add an extension, even if there is already one there, equivalent to addExtension.

"/directory/path" <.> "ext" == "/directory/path.ext"
"/directory/path" <.> ".ext" == "/directory/path.ext"

(</>) :: FilePath -> FilePath -> FilePath

filepath System.FilePath System.FilePath.Posix System.FilePath.Windows

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that readFile (dir </> file) will access the same file as setCurrentDirectory dir; readFile file.

Posix:   "/directory" </> "file.ext" == "/directory/file.ext"
Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
"directory" </> "/file.ext" == "/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

Posix:   "/" </> "test" == "/test"
Posix:   "home" </> "bob" == "home/bob"
Posix:   "x:" </> "foo" == "x:/foo"
Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar"
Windows: "home" </> "bob" == "home\\bob"

Not combined:

Posix:   "home" </> "/bob" == "/bob"
Windows: "home" </> "C:\\bob" == "C:\\bob"

Not combined (tricky): On Windows, if a filepath starts with a single slash, it is relative to the root of the current drive. In [1], this is (confusingly) referred to as an absolute path. The current behavior of </> is to never combine these forms.

Windows: "home" </> "/bob" == "/bob"
Windows: "home" </> "\\bob" == "\\bob"
Windows: "C:\\home" </> "\\bob" == "\\bob"

On Windows, from [1]: "If a file name begins with only a disk designator but not the backslash after the colon, it is interpreted as a relative path to the current directory on the drive with the specified letter." The current behavior of </> is to never combine these forms.

Windows: "D:\\foo" </> "C:bar" == "C:bar"
Windows: "C:\\foo" </> "C:bar" == "C:bar"

(<.>) :: OsPath -> OsString -> OsPath

filepath System.OsPath

Add an extension, even if there is already one there, equivalent to addExtension.

"/directory/path" <.> "ext" == "/directory/path.ext"
"/directory/path" <.> ".ext" == "/directory/path.ext"

(</>) :: OsPath -> OsPath -> OsPath

filepath System.OsPath

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that readFile (dir </> file) will access the same file as setCurrentDirectory dir; readFile file.

Posix:   "/directory" </> "file.ext" == "/directory/file.ext"
Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
"directory" </> "/file.ext" == "/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

Posix:   "/" </> "test" == "/test"
Posix:   "home" </> "bob" == "home/bob"
Posix:   "x:" </> "foo" == "x:/foo"
Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar"
Windows: "home" </> "bob" == "home\\bob"

Not combined:

Posix:   "home" </> "/bob" == "/bob"
Windows: "home" </> "C:\\bob" == "C:\\bob"

Not combined (tricky): On Windows, if a filepath starts with a single slash, it is relative to the root of the current drive. In [1], this is (confusingly) referred to as an absolute path. The current behavior of </> is to never combine these forms.

Windows: "home" </> "/bob" == "/bob"
Windows: "home" </> "\\bob" == "\\bob"
Windows: "C:\\home" </> "\\bob" == "\\bob"

On Windows, from [1]: "If a file name begins with only a disk designator but not the backslash after the colon, it is interpreted as a relative path to the current directory on the drive with the specified letter." The current behavior of </> is to never combine these forms.

Windows: "D:\\foo" </> "C:bar" == "C:bar"
Windows: "C:\\foo" </> "C:bar" == "C:bar"

(<.>) :: PosixPath -> PosixString -> PosixPath

filepath System.OsPath.Posix

Add an extension, even if there is already one there, equivalent to addExtension.

"/directory/path" <.> "ext" == "/directory/path.ext"
"/directory/path" <.> ".ext" == "/directory/path.ext"

(</>) :: PosixPath -> PosixPath -> PosixPath

filepath System.OsPath.Posix

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that readFile (dir </> file) will access the same file as setCurrentDirectory dir; readFile file.

"/directory" </> "file.ext" == "/directory/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

"/" </> "test" == "/test"
"home" </> "bob" == "home/bob"
"x:" </> "foo" == "x:/foo"

Not combined:

"home" </> "/bob" == "/bob"

(<.>) :: ShortByteString -> ShortByteString -> ShortByteString

filepath System.OsPath.Posix.Internal

Add an extension, even if there is already one there, equivalent to addExtension.

"/directory/path" <.> "ext" == "/directory/path.ext"
"/directory/path" <.> ".ext" == "/directory/path.ext"

(</>) :: ShortByteString -> ShortByteString -> ShortByteString

filepath System.OsPath.Posix.Internal

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that readFile (dir </> file) will access the same file as setCurrentDirectory dir; readFile file.

Posix:   "/directory" </> "file.ext" == "/directory/file.ext"
Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
"directory" </> "/file.ext" == "/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

Posix:   "/" </> "test" == "/test"
Posix:   "home" </> "bob" == "home/bob"
Posix:   "x:" </> "foo" == "x:/foo"
Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar"
Windows: "home" </> "bob" == "home\\bob"

Not combined:

Posix:   "home" </> "/bob" == "/bob"
Windows: "home" </> "C:\\bob" == "C:\\bob"

Not combined (tricky): On Windows, if a filepath starts with a single slash, it is relative to the root of the current drive. In [1], this is (confusingly) referred to as an absolute path. The current behavior of </> is to never combine these forms.

Windows: "home" </> "/bob" == "/bob"
Windows: "home" </> "\\bob" == "\\bob"
Windows: "C:\\home" </> "\\bob" == "\\bob"

On Windows, from [1]: "If a file name begins with only a disk designator but not the backslash after the colon, it is interpreted as a relative path to the current directory on the drive with the specified letter." The current behavior of </> is to never combine these forms.

Windows: "D:\\foo" </> "C:bar" == "C:bar"
Windows: "C:\\foo" </> "C:bar" == "C:bar"